从 map 函数看泛型

发表于 | 分类于 |

泛型的应用,先看一段代码

1
2
3
4
5
6
7
8
9
extension Array {
func map<T>(transform: (Element) -> T) -> [T] {
var result: [T] = []
for x in self {
result.append(transform(x))
}
return result
}
}

刚入门Swift看到这段代码会觉得有点懵，毕竟OC之前可没有 T 这种东西

其实这就是 Swift 标准库的 map 函数实现，接受一个数组计算后返回一个新的数组

OC中用过RAC的应该熟悉 map 这个函数。接下来要做的通过一些小案例来解析这段代码

假如需要写一个函数，它接受一个给定的整型数组，通过计算得到并返回一个新数组，新数组各项为原数组中对应的整型数据加一。需要使用一个 for 循环实现：

1
2
3
4
5
6
7
func incrementArray(xs: [Int]) -> [Int] {
var result: [Int] = []
for x in xs {
result.append(x + 1)
}
return result
}

现在假设还需要一个函数，用于生成一个每项都为参数数组对应项两倍的新数组。

1
2
3
4
5
6
7
func doubleArray1(xs: [Int]) -> [Int] {
var result: [Int] = []
for x in xs {
result.append(x * 2)
}
return result
}

这两个函数有大量相同的代码，能不能将没有区别的地方抽象出来，并单独写一个体现这种模式且更通用的函数呢？像这样的函数需要追加一个新参数来接受一个函数，这个参数能根据各个数组项计算得到新的整型数值

1
2
3
4
5
6
7
8
func computeIntArray(xs: [Int], transform: (Int) -> Int) -> [Int] {
var result: [Int] = []
for x in xs {
result.append(transform(x))
}
return result
}
//注意这里 transform: Int -> Int 是一个函数 , 接受整型 然后返回整型

现在可以向函数传递不同的参数。doubleArray 函数和 incrementArray 函数都精简成了一行调用 computeIntArray 的语句

1
2
3
computeIntArray(xs) { x in x * 2 }
computeIntArray(xs) { x in x + 1 }

如果想要得到一个布尔型的新数组，用于表示原数组中对应的数字是否是偶数。可能会尝试编写一些像下面这样的代码：

1
2
3
func isEvenArray(xs: [Int]) -> [Bool] {
computeIntArray(xs) { x in x % 2 == 0 }
}

这段代码导致了一个类型错误。问题在于， computeIntArray 函数接受一个 Int -> Int 类型的参数，也就是说，该参数是一个返回整型值的函数。而在 isEvenArray 函数的定义中，传递了一个 Int -> Bool 类型的参数，于是导致了类型错误。

一种可行方案是定义新版本的 computeIntArray 函数，接受一个 Int -> Bool 类型的函数作为参数。类似下面这样：

1
2
3
4
5
6
7
8
func computeBoolArray(xs: [Int], transform: (Int) -> Bool) -> [Bool] {
var result: [Bool] = []
for x in xs {
result.append(transform(x))
}
return result
}

但是，这个方案的扩展性并不好。如果接下来需要计算 String 类型,还需要定义另一个高阶函数来接受 Int -> String 类型的参数

这种情况下,泛型就该上场了。
computeBoolArray 和 computeIntArray 的定义是相同的；唯一的区别在于类型签名 (type signature)。假如定义一个相似的函数 computeStringArray 来支持 String 类型，其函数体将会与先前两个函数完全一致。事实上，相同部分的代码可以用于任何类型。真正想做的是写一个能够适用于每种可能类型的泛型函数：

1
2
3
4
5
6
7
func genericComputeArray1<T>(xs: [Int], transform:(Int) -> T) -> [T] {
var result: [T] = []
for x in xs {
result.append(transform(x))
}
return result
}

关于这段代码，最有意思的是它的类型签名。理解这个类型签名有助于你将 genericComputeArray 理解为一个函数族。类型参数 T 的每个选择都会确定一个新函数。该函数接受一个整型数组和一个 Int -> T 类型的函数作为参数，并返回一个 [T] 类型的数组。

仍能进一步将这个函数一般化。没有理由让它仅能对类型为 [Int] 的输入数组进行处理。将数组类型进行抽象，能得到下面这样的类型签名：

1
2
3
4
5
6
7
func map<Element, T>(xs: [Element], transform: (Element) -> T) -> [T] {
var result: [T] = []
for x in xs {
result.append(transform(x))
}
return result
}

现在回过头看第一段代码，有没有很通透了

1
2
3
4
5
6
7
8
9
extension Array {
func map<T>(transform: (Element) -> T) -> [T] {
var result: [T] = []
for x in self {
result.append(transform(x))
}
return result
}
}

transform 参数中所使用的 Element 类型源自于 Swift 的 Array 中对 Element 所进行的泛型定义。

然后这里是泛型的官方说明,可以进一步了解